home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / Networking / AFP C++ / AFPSession.cp < prev    next >
Encoding:
Text File  |  1992-05-01  |  41.3 KB  |  2,145 lines  |  [TEXT/MPS ]
  1. /************************************************************
  2.  
  3. Created: Monday, Sept 23, 1991
  4.     AFPSession.cp
  5.     C++ Interface to the AppleTalk Filing Protocol
  6.     M.Vierling
  7.  
  8.  
  9.         Copyright Apple Computer, Inc. 1985-1991
  10.         All rights reserved
  11.  
  12. ************************************************************/
  13.  
  14. #include <Types.h>
  15. #include <CType.h>
  16. #include <Errors.h>
  17. #include <String.h>
  18. #include <Strings.h>
  19. #include "AFPSession.h"
  20.  
  21. typedef        MPPParamBlock    *MPPParamBlkPtr,    **MPPParamBlkHdl;    // CFront returns internal error: hased lookup if we don't typedef these - weird!
  22. typedef        MPPparms        *MPPparmsPtr,        **MPPparmsHdl;
  23. typedef        LAPparms        *LAPparmsPtr,        **LAPparmsHdl;
  24. typedef        DDPparms        *DDPparmsPtr,        **DDPparmsHdl;
  25. typedef        NBPparms        *NBPparmsPtr,        **NBPparmsHdl;
  26.  
  27. #pragma segment AFPCall
  28.  
  29. const unsigned short kMaxBufSize = 4096;
  30. const unsigned short kMinBufSize = 4;
  31.  
  32. TAFPSession::TAFPSession()
  33. {
  34.     this->Debug(0, "AFPSession constructor:");
  35.     
  36.     fCBStart = (Ptr)(new char[ kMaxBufSize ]);
  37.     fRBStart = (Ptr)(new char[ kMaxBufSize ]);
  38.  
  39.     fCBptr = fCBStart;
  40.     fRBptr = fRBStart;
  41.     
  42.     this->SetAFPVersion( "AFPVersion 2.1" );
  43.     
  44.     fPathDelimiter = ':';
  45. }
  46.  
  47.  
  48. OSErr TAFPSession::ISession( AddrBlock theAddress )
  49. {
  50.     this->Debug(0, "ISession");
  51.     this->SetAddress( theAddress );
  52.     return this->IAFPCall();
  53. }
  54.  
  55. TAFPSession::~TAFPSession()
  56. {
  57.     this->Debug(0, "AFPSession destructor:");
  58.     delete [] fCBStart;
  59.     delete [] fRBStart;
  60. }
  61.  
  62. void TAFPSession::SetAddress( AddrBlock theAddress )
  63. {
  64.     fafpAddrBlock = theAddress;
  65. }
  66.  
  67. AddrBlock TAFPSession::GetAddress()
  68. {
  69.     return fafpAddrBlock;
  70. }
  71.  
  72. inline OSErr TAFPSession::MakeAFPCall()
  73. {
  74.     return this->DoCommand( fCBStart, fCBSize, fRBStart, fRBSize );
  75. }
  76.  
  77. OSErr TAFPSession::GetError()
  78. {
  79.     return fErrResult;
  80. }
  81.  
  82. void TAFPSession::bytePush( Byte theByte )
  83. {
  84.     *fCBptr = theByte;
  85.     fCBptr++;
  86.     fCBSize = fCBptr - fCBStart;
  87. }
  88.  
  89. void TAFPSession::shortPush( short theShort )
  90. {
  91.     *(short *)fCBptr = theShort;
  92.     fCBptr += 2;
  93.     fCBSize = fCBptr - fCBStart;
  94. }
  95.  
  96. void TAFPSession::longPush( long theLong )
  97. {
  98.     *(long *)fCBptr = theLong;
  99.     fCBptr += 4;
  100.     fCBSize = fCBptr - fCBStart;
  101. }
  102.  
  103. void TAFPSession::arrayPush( char * arrayName, unsigned int arrayLen )
  104. {
  105.     memcpy( fCBptr, arrayName, arrayLen );
  106.     fCBptr += arrayLen;
  107.     fCBSize = fCBptr - fCBStart;
  108. }
  109.  
  110. void TAFPSession::stringPush( char * stringName )
  111. {
  112.     strcpy( fCBptr, stringName );
  113.     c2pstr( fCBptr );
  114.     fCBSize = strlen(stringName);    // temporarily use this since *fCBptr doesn't seem to work
  115.     fCBptr = fCBptr + fCBSize + 1;
  116.     fCBSize = fCBptr - fCBStart;
  117. }
  118.  
  119. void TAFPSession::pathPush( Byte PathType, char * Pathname )
  120. {
  121.     long count;
  122.     char* stringPtr;
  123.     
  124.     *(Byte *)fCBptr = PathType;
  125.     fCBptr += 1;
  126.     stringPtr = fCBptr;
  127.     this->stringPush( Pathname );
  128.     
  129.     count = strlen(Pathname);
  130.     for ( long i = 0; i < count; i++ )
  131.     {
  132.         stringPtr++;
  133.         if (*stringPtr == fPathDelimiter)
  134.             *stringPtr = '\0';
  135.     }
  136. }
  137.  
  138. void TAFPSession::passwordPush( char * Password )
  139. {
  140.     this->passwordCreate( (PassWord *)fCBptr, Password );
  141.     fCBptr += 8;        
  142.     fCBSize = fCBptr - fCBStart;
  143. }
  144.  
  145. void TAFPSession::passwordCreate( PassWord * password, char * string )
  146. {
  147.     long length, i;
  148.     char * myPtr;
  149.     
  150.     if (string == NULL)
  151.     {
  152.         length = 0;
  153.     }
  154.     else
  155.     {
  156.         length = strlen( string );
  157.         memcpy( password, string, 8 );
  158.     }
  159.     myPtr = (char *)password + length;
  160.     for (i = length; i < 8; i++)
  161.     {
  162.         *myPtr = '\0';
  163.         myPtr++;
  164.     }
  165. }
  166.  
  167. #ifdef __DES__
  168. void TAFPSession::desPush( PassWord * Key, PassWord * Password, Boolean useNewDES )
  169. {
  170.     KeysArray aKeyarray;
  171.     EncryptBlk theKey;
  172.     long *myPtr = nil;
  173.     EncryptBlk thePassword;
  174.  
  175.     myPtr = (long *)Key;
  176.     theKey[0] = *myPtr;
  177.     myPtr++;
  178.     theKey[1] = *myPtr;
  179.  
  180.     myPtr = (long *)Password;
  181.     thePassword[0] = *myPtr;
  182.     myPtr++;
  183.     thePassword[1] = *myPtr;
  184.  
  185.     myPtr = (long *)&thePassword;
  186.     
  187.     if (useNewDES)
  188.         LowBitsKeySched( (long *)theKey, aKeyarray );
  189.     else
  190.         HiBitsKeySched( (long *)theKey, aKeyarray );
  191.     Encode( aKeyarray, 8, &myPtr );
  192.  
  193.     this->arrayPush( (char *)thePassword, 8 );
  194. }
  195. #else
  196. void TAFPSession::desPush( PassWord * /* Key */, PassWord * Password, Boolean /* useNewDES */ )
  197. {
  198.     this->arrayPush( (char *)Password, 8 );
  199. }
  200. #endif    
  201.  
  202. void TAFPSession::fileDirPush( short Bitmap, FileDirBlock& theBlock )
  203. {
  204.     short * longNamePtr;
  205.     short * shortNamePtr;
  206.     char * startPtr;
  207.     
  208.     startPtr = fCBptr;
  209.     if (Bitmap & 0x01)
  210.         this->shortPush( theBlock.Attributes );
  211.     if (Bitmap & 0x02)
  212.         this->longPush( theBlock.ParentDirID );
  213.     if (Bitmap & 0x04)
  214.         this->longPush( theBlock.CreateDate );
  215.     if (Bitmap & 0x08)
  216.         this->longPush( theBlock.ModDate );
  217.     if (Bitmap & 0x10)
  218.         this->longPush( theBlock.BackupDate );
  219.     if (Bitmap & 0x20)
  220.         this->arrayPush( (char *)theBlock.FinderInfo, 32 );
  221.     if (Bitmap & 0x40) {
  222.         longNamePtr = (short *)fCBptr;
  223.         this->shortPush( theBlock.LongName );
  224.     }
  225.     if (Bitmap & 0x80) {
  226.         shortNamePtr = (short *)fCBptr;
  227.         this->shortPush( theBlock.ShortName );
  228.     }
  229.     if (theBlock.FileDirFlag == 0)
  230.     {
  231.         if (Bitmap & 0x100)
  232.             this->longPush( theBlock.File.FileNumber );
  233.         if (Bitmap & 0x200)
  234.             this->longPush( theBlock.File.DataLength );
  235.         if (Bitmap & 0x400)
  236.             this->longPush( theBlock.File.RsrcLength );
  237.     }
  238.     else
  239.     {
  240.         if (Bitmap & 0x100)
  241.             this->longPush( theBlock.Dir.DirID );
  242.         if (Bitmap & 0x200)
  243.             this->shortPush( theBlock.Dir.OffspringCount );
  244.         if (Bitmap & 0x400)
  245.             this->longPush( theBlock.Dir.OwnerID );
  246.         if (Bitmap & 0x800)
  247.             this->longPush( theBlock.Dir.GroupID );
  248.         if (Bitmap & 0x1000)
  249.             this->longPush( theBlock.Dir.AccessRights );
  250.     }
  251.     if (Bitmap & 0x2000)
  252.     {
  253.         this->shortPush( theBlock.ProDOSFileType );
  254.         this->longPush( theBlock.ProDOSAuxType );
  255.     }
  256.     if (Bitmap & 0x40)
  257.         *longNamePtr = fCBptr - startPtr;
  258.     if (Bitmap & 0x80)
  259.         *shortNamePtr = fCBptr - startPtr;    // I'm assuming that short and long names are never set simultaneously
  260. }
  261.  
  262. void TAFPSession::specPush( short Bitmap, FileDirBlock& theBlock, char * string )
  263. {
  264.     Spec * theSpec;
  265.     
  266.     theSpec = (Spec *)fCBptr;
  267.     fCBptr += 2;
  268. //    if (*string == '\0') {
  269. //        Bitmap &= 0xFF3F;    // Clear shortname and longname bits
  270. //    }
  271.     this->fileDirPush( Bitmap, theBlock );
  272.     if (*string != '\0') {
  273.         this->stringPush( string );
  274.     }
  275.     theSpec->length = fCBptr - (Ptr)theSpec - 2;
  276.     theSpec->filler = 0;
  277. }
  278.  
  279. void TAFPSession::alignPush()
  280. {
  281.     long digit;
  282.     
  283.     if ((digit = (unsigned long)fCBptr) & 1L) {        // is fCBptr odd?
  284.         *fCBptr = '\0';                                // then move it to a word boundary
  285.         fCBptr++;
  286.     }
  287.     fCBSize = fCBptr - fCBStart;
  288. }
  289.  
  290. Ptr TAFPSession::GetReply()
  291. {
  292.     return fRBStart;
  293. }
  294.  
  295. short TAFPSession::SetVolumeID( short VolumeID )
  296. {
  297.     short oldVolumeID;
  298.     
  299.     oldVolumeID = fVolumeID;
  300.     fVolumeID = VolumeID;
  301.     return oldVolumeID;
  302. }
  303.  
  304. short TAFPSession::GetVolumeID()
  305. {
  306.     return fVolumeID;
  307. }
  308.  
  309. long TAFPSession::SetDirID( long DirID )
  310. {
  311.     long oldDirID;
  312.     
  313.     oldDirID = fDirID;
  314.     fDirID = DirID;
  315.     return oldDirID;
  316. }
  317.  
  318. long TAFPSession::GetDirID()
  319. {
  320.     return fDirID;
  321. }
  322.  
  323. short TAFPSession::SetForkID( short OForkRefNum )
  324. {
  325.     short oldOForkRefNum;
  326.     
  327.     oldOForkRefNum = fOForkRefNum;
  328.     fOForkRefNum = OForkRefNum;
  329.     return oldOForkRefNum;
  330. }
  331.  
  332. short TAFPSession::GetForkID()
  333. {
  334.     return fOForkRefNum;
  335. }
  336.  
  337. short TAFPSession::GetIDNum()
  338. {
  339.     return 0;
  340. }
  341.  
  342. short TAFPSession::SetDTRefNum( short DTRefNum )
  343. {
  344.     short oldDTRefNum;
  345.     
  346.     oldDTRefNum = fDTRefNum;
  347.     fDTRefNum = DTRefNum;
  348.     return oldDTRefNum;
  349. }
  350.  
  351. short TAFPSession::GetDTRefNum()
  352. {
  353.     return fDTRefNum;
  354. }
  355.  
  356. short TAFPSession::SetUserID( short /* UserID */ )
  357. {
  358.     return 0;
  359. }
  360.  
  361. short TAFPSession::GetUserID()
  362. {
  363.     return 0;
  364. }
  365.  
  366. long TAFPSession::SetMapID( long MapID )
  367. {
  368.     long oldMapID;
  369.     
  370.     oldMapID = fMapID;
  371.     fMapID = MapID;
  372.     return oldMapID;
  373. }
  374.  
  375. long TAFPSession::GetMapID()
  376. {
  377.     return fMapID;
  378. }
  379.  
  380. long TAFPSession::SetFileID( long FileID )
  381. {
  382.     long oldFileID;
  383.     
  384.     oldFileID = fFileID;
  385.     fFileID = FileID;
  386.     return oldFileID;
  387. }
  388.  
  389. long TAFPSession::GetFileID()
  390. {
  391.     return fFileID;
  392. }
  393.  
  394. long TAFPSession::GetActCount()
  395. {
  396.     return fActCount;
  397. }
  398.  
  399. long TAFPSession::GetOffset()
  400. {
  401.     return fOffset;
  402. }
  403.  
  404. void TAFPSession::SetAFPVersion( char * version )
  405. {
  406.     strcpy( fAFPVersion, version );
  407. }
  408.  
  409. char * TAFPSession::GetAFPVersion()
  410. {
  411.     return fAFPVersion;
  412. }
  413.  
  414. void TAFPSession::SetPathDelimiter( char delimiter )
  415. {
  416.     fPathDelimiter = delimiter;
  417. }
  418.  
  419. char TAFPSession::GetPathDelimiter()
  420. {
  421.     return fPathDelimiter;
  422. }
  423.  
  424. OSErr TAFPSession::GetSrvrInfo()
  425. {
  426.     this->Debug(0, "GetSrvrInfo");
  427.     fRBSize        = kMaxBufSize;
  428.     
  429.     return DoGetStatus( fRBStart, fRBSize, fafpAddrBlock );
  430. }
  431.  
  432.  
  433. OSErr TAFPSession::GetSrvrParms()
  434. {
  435.     struct commandBuffer {
  436.         Byte command;
  437.     } *cbPtr;
  438.     
  439.     this->Debug(0, "GetSrvrParms");
  440.  
  441.     fCBSize = sizeof( commandBuffer );
  442.     fRBSize = kMaxBufSize;                    
  443.     cbPtr = (commandBuffer *)fCBStart;
  444.     
  445.     cbPtr->command = afpGetSParms;
  446.     
  447.     return this->MakeAFPCall();
  448. }
  449.  
  450. OSErr TAFPSession::GetSrvrMsg( short MsgType, short MsgBitmap )
  451. {
  452.     struct commandBuffer {
  453.         Byte command;
  454.         Byte filler;
  455.         short MsgType;
  456.         short MsgBitmap;
  457.     } *cbPtr;
  458.     
  459.     this->Debug(0, "GetSrvrMsg");
  460.  
  461.     fCBSize = sizeof( commandBuffer );
  462.     fRBSize = kMaxBufSize;                    
  463.     cbPtr = (commandBuffer *)fCBStart;
  464.     
  465.     cbPtr->command = afpGetSrvrMsg;
  466.     cbPtr->MsgType = MsgType;
  467.     cbPtr->MsgBitmap = MsgBitmap;
  468.     
  469.     return this->MakeAFPCall();
  470. }
  471.  
  472. OSErr TAFPSession::LoginGuest()
  473. {
  474.     this->Debug(0, "LoginGuest");
  475.     
  476.     return this->Login( fAFPVersion, "No User Authent", 0, 0 );
  477. }
  478.  
  479. OSErr TAFPSession::LoginCleartxt( char * UserName, char * Password )
  480. {
  481.     this->Debug(0, "LoginCleartxt");
  482.     
  483.     return this->Login( fAFPVersion, "Cleartxt Passwrd", UserName, Password );
  484. }
  485.  
  486. OSErr TAFPSession::LoginRandnum( char * UserName, char * Password )
  487. {
  488.     short IDNumber;
  489.     char UserAuthInfo[8];
  490.     
  491.     struct replyBuffer {
  492.         short IDNumber;
  493.         char UserAuthInfo[8];
  494.     } * rbPtr;
  495.  
  496.     this->Debug(0, "LoginRandnum");
  497.     
  498.     this->Login( fAFPVersion, "Randnum Exchange", UserName, 0 );
  499.     if ( fErrResult != afpAuthContinue )
  500.         return fErrResult;
  501.     
  502.     rbPtr = (replyBuffer *)fRBStart;
  503.     
  504.     IDNumber = rbPtr->IDNumber;
  505.  
  506.     memcpy( UserAuthInfo, rbPtr->UserAuthInfo, 8 ); 
  507.  
  508.     return this->LoginCont( IDNumber, UserAuthInfo, Password );
  509. }
  510.  
  511. OSErr TAFPSession::Login2Way( char * UserName, char * Password )
  512. {
  513.     short IDNumber;
  514.     char SrvrAuthInfo[8];
  515.     
  516.     struct replyBuffer {
  517.         short IDNumber;
  518.         char SrvrAuthInfo[8];
  519.     } * rbPtr;
  520.  
  521.     this->Debug(0, "Login2Way");
  522.     
  523.     this->Login( fAFPVersion, "2-Way Randnum exchange", UserName, 0 );
  524.     if ( fErrResult != afpAuthContinue )
  525.         return fErrResult;
  526.     
  527.     rbPtr = (replyBuffer *)fRBStart;
  528.     
  529.     IDNumber = rbPtr->IDNumber;
  530.  
  531.     memcpy( SrvrAuthInfo, rbPtr->SrvrAuthInfo, 8 ); 
  532.  
  533.     return this->LoginCont2Way( IDNumber, SrvrAuthInfo, Password, "EncodeMe" );
  534. }
  535.     
  536. OSErr TAFPSession::LoginCont2Way(  short IDNumber,
  537.                                    char * UserAuthInfo,
  538.                                    char * Password,
  539.                                    char * UserRandNum )
  540. {
  541.     struct commandBuffer {
  542.         Byte command;
  543.         Byte filler;
  544.         short IDNumber;
  545.         char marker;
  546.     } *cbPtr;
  547.     
  548.     PassWord passW;
  549.     PassWord * passWPtr;
  550.     passWPtr = (PassWord *)&passW[0];
  551.     
  552.     this->Debug(0, "LoginCont2Way");
  553.         
  554.     fCBSize = sizeof( commandBuffer );
  555.     fRBSize = 10;                    
  556.     cbPtr = (commandBuffer *)fCBStart;
  557.     
  558.     cbPtr->command = afpContLogin;
  559.     cbPtr->filler = '\0';
  560.     cbPtr->IDNumber = IDNumber;
  561.  
  562.     fCBptr = &(cbPtr->marker);
  563.     
  564.     this->passwordCreate( passWPtr, Password );
  565.     this->desPush( passWPtr, (PassWord *)UserAuthInfo, true );
  566.     this->passwordCreate( passWPtr, UserRandNum );
  567.     this->arrayPush( (char *)passWPtr, 8 );
  568.     
  569.     return this->MakeAFPCall();
  570. }
  571.  
  572. OSErr TAFPSession::Login( char * AFPVersion,
  573.                          char * UAM,
  574.                          char * UserName,
  575.                          char * Password )
  576. {
  577.     struct commandBuffer {
  578.         Byte command;
  579.         char marker;
  580.     } *cbPtr;
  581.     
  582.     this->Debug(0, "Login");
  583.         
  584.     fCBSize = sizeof( commandBuffer );
  585.     fRBSize = 10;                    
  586.     cbPtr = (commandBuffer *)fCBStart;
  587.         
  588.     cbPtr->command = afpLogin;
  589.     
  590.     fCBptr = &(cbPtr->marker);
  591.     stringPush( AFPVersion );
  592.     stringPush( UAM );
  593.     
  594.     stringPush( UserName );
  595.     if (Password != NULL)
  596.     {
  597.         alignPush();
  598.         passwordPush( Password );
  599.     }
  600.     
  601.     return this->DoLogin( fCBStart, fCBSize, fRBStart, fRBSize, fafpAddrBlock );
  602. }
  603.  
  604.  
  605. OSErr TAFPSession::LoginCont( short IDNumber,
  606.                              char * UserAuthInfo,
  607.                              char * Password )
  608. {
  609.     struct commandBuffer {
  610.         Byte command;
  611.         Byte filler;
  612.         short IDnumber;
  613.         char marker;
  614.     } *cbPtr;
  615.     
  616.     PassWord passX;
  617.     PassWord * passXPtr;
  618.     passXPtr = (PassWord *)&passX[0];
  619.     
  620.     this->Debug(0, "LoginCont");
  621.         
  622.     fCBSize = sizeof( commandBuffer );
  623.     fRBSize = 10;                    
  624.     cbPtr = (commandBuffer *)fCBStart;
  625.     
  626.     cbPtr->command = afpContLogin;
  627.     cbPtr->filler = '\0';
  628.     cbPtr->IDnumber = IDNumber;
  629.  
  630.     fCBptr = &(cbPtr->marker);
  631.     
  632.     this->passwordCreate( passXPtr, Password );
  633.     this->desPush( passXPtr, (PassWord *)UserAuthInfo, false );
  634.     
  635.     return this->MakeAFPCall();
  636. }
  637.  
  638.  
  639. OSErr TAFPSession::Logout()
  640. {
  641.     this->Debug(0, "Logout");
  642.     
  643.     return this->DoLogout();
  644. }
  645.  
  646. OSErr TAFPSession::MapID( long UserID, char FnType )
  647. {
  648.     struct commandBuffer {
  649.         Byte command;
  650.         Byte subfunction;
  651.         long ID;
  652.     } *cbPtr;
  653.  
  654.     this->Debug(0, "MapID");
  655.     
  656.     fCBSize = sizeof( commandBuffer );
  657.     fRBSize = kMaxBufSize;
  658.     cbPtr = (commandBuffer *)fCBStart;
  659.     
  660.     cbPtr->command = afpMapID;
  661.     cbPtr->subfunction = FnType;
  662.     cbPtr->ID = UserID;
  663.  
  664.     return( this->MakeAFPCall() );
  665. }
  666.  
  667. OSErr TAFPSession::MapName( char * UserName, char FnType )
  668. {
  669.     struct commandBuffer {
  670.         Byte command;
  671.         Byte subfunction;
  672.         char marker;
  673.     } *cbPtr;
  674.     
  675.     this->Debug(0, "MapName");
  676.     
  677.     fCBSize = sizeof( commandBuffer );
  678.     fRBSize = kMaxBufSize;
  679.     cbPtr = (commandBuffer *)fCBStart;
  680.     
  681.     cbPtr->command = afpMapName;
  682.     cbPtr->subfunction = FnType;
  683.     
  684.     fCBptr = &(cbPtr->marker);
  685.     this->stringPush( UserName );
  686.  
  687.     this->MakeAFPCall();
  688.     
  689.     fMapID = *(long *)fRBStart;
  690.     
  691.     return fErrResult;
  692. }
  693.  
  694. OSErr TAFPSession::ChangePassword( char * UAM,
  695.                                   char * UserName,
  696.                                   char * OldPassword,
  697.                                   char * NewPassword )
  698. {
  699.     PassWord passX;
  700.     PassWord passY;
  701.     PassWord * passXPtr;
  702.     passXPtr = (PassWord *)&passX[0];
  703.     PassWord * passYPtr;
  704.     passYPtr = (PassWord *)&passY[0];
  705.     
  706.     this->Debug(0, "ChangePassword");
  707.     
  708.     fRBSize = kMaxBufSize;
  709.     
  710.     fCBptr = fCBStart;
  711.     this->bytePush( afpChangePwd );
  712.     this->alignPush();
  713.     this->stringPush( UAM );
  714.     this->alignPush();
  715.     this->stringPush( UserName );
  716.     this->alignPush();
  717.     if ( strcmp( UAM, "Randnum Exchange") == 0 )
  718.     {
  719.         this->passwordCreate( passXPtr, NewPassword );
  720.         this->passwordCreate( passYPtr, OldPassword );
  721.         this->desPush( passXPtr, passYPtr, false );
  722.         this->desPush( passYPtr, passXPtr, false );
  723.     }
  724.     else
  725.     {
  726.         this->passwordPush( OldPassword );
  727.         this->passwordPush( NewPassword );
  728.     }
  729.     return this->MakeAFPCall();
  730. }
  731.  
  732. OSErr TAFPSession::GetUserInfo(
  733.                   Byte ThisUserFlag,
  734.                   short Bitmap,
  735.                   long UserID )
  736. {
  737.     struct commandBuffer {
  738.         Byte command;
  739.         Byte ThisUserFlag;
  740.         long UserID;
  741.         short Bitmap;
  742.     } *cbPtr;
  743.  
  744.     this->Debug(0, "GetUserInfo");
  745.     
  746.     fCBSize = sizeof( commandBuffer );
  747.     fRBSize = 10;
  748.     cbPtr = (commandBuffer *)fCBStart;
  749.     
  750.     cbPtr->command = afpGetUserInfo;
  751.     cbPtr->ThisUserFlag = ThisUserFlag;
  752.     cbPtr->UserID = UserID;
  753.     cbPtr->Bitmap = Bitmap;
  754.                         
  755.     return this->MakeAFPCall();
  756. }
  757.  
  758.  
  759. /* Volume Calls     ----------------------------------------------------------------- */
  760.  
  761. OSErr TAFPSession::OpenVol( char * VolumeName, char * Password, short Bitmap )
  762. {
  763.     struct commandBuffer {
  764.         Byte command;
  765.         Byte filler;
  766.         short Bitmap;
  767.         char marker;
  768.     } *cbPtr;
  769.     
  770.     struct replyBuffer {
  771.         short Bitmap;
  772.         short VolumeID;
  773.     } *rbPtr;
  774.     
  775.     this->Debug(0, "OpenVol");
  776.  
  777.     if (Bitmap != 0x20)
  778.         this->OpenVol( VolumeName, Password, 0x20 );
  779.  
  780.      fCBSize = sizeof( commandBuffer );
  781.     fRBSize = kMaxBufSize;                    
  782.     cbPtr = (commandBuffer *)fCBStart;
  783.     
  784.     cbPtr->command = afpOpenVol;
  785.     cbPtr->filler = '\0';
  786.     cbPtr->Bitmap = Bitmap;
  787.     
  788.     fCBptr = &(cbPtr->marker);
  789.     this->stringPush( VolumeName );
  790.     if (Password)
  791.     {
  792.         this->alignPush();
  793.         this->arrayPush( Password, 8 );
  794.     }
  795.  
  796.     this->MakeAFPCall();
  797.     
  798.     rbPtr = (replyBuffer *)fRBStart;
  799.     if ( rbPtr->Bitmap == 0x20 )
  800.     {
  801.         fVolumeID = rbPtr->VolumeID;
  802.     }
  803.     
  804.     return fErrResult;
  805. }
  806.  
  807. OSErr TAFPSession::SetVolParms( short VolumeID, short Bitmap, long BackupDate )
  808. {
  809.     struct commandBuffer {
  810.         Byte command;
  811.         Byte filler;
  812.         short VolumeID;
  813.         short Bitmap;
  814.         long BackupDate;
  815.     } *cbPtr;
  816.     
  817.     this->Debug(0, "SetVolParms");
  818.  
  819.     fCBSize = sizeof( commandBuffer );
  820.     fRBSize = kMinBufSize;                    
  821.     cbPtr = (commandBuffer *)fCBStart;
  822.     
  823.     cbPtr->command = afpSetVolParms;
  824.     cbPtr->filler = '\0';
  825.     cbPtr->VolumeID = VolumeID;
  826.     cbPtr->Bitmap = Bitmap;
  827.     cbPtr->BackupDate = BackupDate;
  828.     
  829.     return this->MakeAFPCall();
  830. }
  831.  
  832. OSErr TAFPSession::GetVolParms( short VolumeID, short Bitmap )
  833. {
  834.     struct commandBuffer {
  835.         Byte command;
  836.         Byte filler;
  837.         short VolumeID;
  838.         short Bitmap;
  839.     } *cbPtr;
  840.     
  841.     this->Debug(0, "GetVolParms");
  842.  
  843.     fCBSize = sizeof( commandBuffer );
  844.     fRBSize = kMaxBufSize;                    
  845.     cbPtr = (commandBuffer *)fCBStart;
  846.     
  847.     cbPtr->command = afpGetVolParms;
  848.     cbPtr->filler = '\0';
  849.     cbPtr->VolumeID = VolumeID;
  850.     cbPtr->Bitmap = Bitmap; 
  851.     
  852.     return this->MakeAFPCall();
  853. }
  854.  
  855. OSErr TAFPSession::Flush( short VolumeID )
  856. {
  857.     struct commandBuffer {
  858.         Byte command;
  859.         Byte filler;
  860.         short VolumeID;
  861.     } *cbPtr;
  862.     
  863.     this->Debug(0, "Flush");
  864.     
  865.     fCBSize = sizeof( commandBuffer );
  866.     fRBSize = kMinBufSize;
  867.     cbPtr = (commandBuffer *)fCBStart;
  868.     
  869.     cbPtr->command = afpFlush;
  870.     cbPtr->filler = '\0';
  871.     cbPtr->VolumeID = VolumeID;
  872.     
  873.     return this->MakeAFPCall();
  874. }
  875.  
  876. OSErr TAFPSession::CloseVol( short VolumeID )
  877. {
  878.     struct commandBuffer {
  879.         Byte command;
  880.         Byte filler;
  881.         short VolumeID;
  882.     } *cbPtr;
  883.  
  884.     this->Debug(0, "CloseVol");
  885.     
  886.     fCBSize = sizeof( commandBuffer );
  887.     fRBSize = kMinBufSize;
  888.     cbPtr = (commandBuffer *)fCBStart;
  889.     
  890.     cbPtr->command = afpVolClose;
  891.     cbPtr->filler = '\0';
  892.     cbPtr->VolumeID = VolumeID;
  893.     
  894.     return this->MakeAFPCall();
  895. }
  896.  
  897.  
  898.  
  899. /* Directory Calls ----------------------------------------------------------- */
  900.  
  901. OSErr TAFPSession::SetDirParms( short VolumeID,
  902.                                long DirID,
  903.                                short Bitmap,
  904.                                Byte PathType,
  905.                                char * Pathname,
  906.                                FileDirBlock& theBlock )
  907. {
  908.     struct commandBuffer {
  909.         Byte command;
  910.         Byte filler;
  911.         short VolumeID;
  912.         long DirID;
  913.         short Bitmap;
  914.         char marker;
  915.     } *cbPtr;
  916.     
  917.     this->Debug(0, "SetDirParms");
  918.     
  919.     fCBSize = sizeof( commandBuffer );
  920.     fRBSize = kMaxBufSize;
  921.     cbPtr = (commandBuffer *)fCBStart;
  922.     
  923.     cbPtr->command = afpSetDirParms;
  924.     cbPtr->filler = '\0';
  925.     cbPtr->VolumeID = VolumeID;
  926.     cbPtr->DirID = DirID;
  927.     cbPtr->Bitmap = Bitmap;
  928.     
  929.     fCBptr = &(cbPtr->marker);
  930.     this->pathPush( PathType, Pathname );
  931.     this->alignPush();
  932.     theBlock.FileDirFlag = 0x8000;
  933.     this->fileDirPush( Bitmap, theBlock );
  934.     
  935.     return this->MakeAFPCall();
  936. }
  937.  
  938. OSErr TAFPSession::OpenDir( short VolumeID,
  939.                            long DirID,
  940.                            Byte PathType,
  941.                            char * Pathname )
  942. {
  943.     struct commandBuffer {
  944.         Byte command;
  945.         Byte filler;
  946.         short VolumeID;
  947.         long DirID;
  948.         char marker;
  949.     } *cbPtr;
  950.     
  951.     this->Debug(0, "OpenDir");
  952.  
  953.     fCBSize = sizeof( commandBuffer );
  954.     fRBSize = kMaxBufSize;
  955.     cbPtr = (commandBuffer *)fCBStart;
  956.     
  957.     cbPtr->command = afpOpenDir;
  958.     cbPtr->filler = '\0';
  959.     cbPtr->VolumeID = VolumeID;
  960.     cbPtr->DirID = DirID;
  961.     
  962.     fCBptr = &(cbPtr->marker);
  963.     this->pathPush( PathType, Pathname );
  964.     
  965.     this->MakeAFPCall();
  966.     
  967.     fDirID = *(long *)fRBStart;
  968.     
  969.     return fErrResult;
  970. }
  971.  
  972. OSErr TAFPSession::CloseDir( short VolumeID, long DirID )
  973. {
  974.     struct commandBuffer {
  975.         Byte command;
  976.         Byte filler;
  977.         short VolumeID;
  978.         long DirID;
  979.     } *cbPtr;
  980.     
  981.     this->Debug(0, "CloseDir");
  982.  
  983.     fCBSize = sizeof( commandBuffer );
  984.     fRBSize = kMaxBufSize;
  985.     cbPtr = (commandBuffer *)fCBStart;
  986.     
  987.     cbPtr->command = afpDirClose;
  988.     cbPtr->filler = '\0';
  989.     cbPtr->VolumeID = VolumeID;
  990.     cbPtr->DirID = DirID;
  991.  
  992.     return this->MakeAFPCall();
  993. }
  994.  
  995. OSErr TAFPSession::Enumerate( short VolumeID,
  996.                              long DirID,
  997.                              short FileBitmap,
  998.                              short DirBitmap,
  999.                              short ReqCount,
  1000.                              short StartIndex,
  1001.                              short MaxReplySize,
  1002.                              Byte PathType,
  1003.                              char * Pathname )
  1004. {
  1005.     struct commandBuffer {
  1006.         Byte command;
  1007.         Byte filler;
  1008.         short VolumeID;
  1009.         long DirID;
  1010.         short FileBitmap;
  1011.         short DirBitmap;
  1012.         short ReqCount;
  1013.         short StartIndex;
  1014.         short MaxReplySize;
  1015.         char marker;
  1016.     } *cbPtr;
  1017.         
  1018.     this->Debug(0, "Enumerate");
  1019.  
  1020.     fCBSize = sizeof( commandBuffer );
  1021.     fRBSize = MaxReplySize;
  1022.     cbPtr = (commandBuffer *)fCBStart;
  1023.     
  1024.     cbPtr->command = afpEnumerate;
  1025.     cbPtr->filler = '\0';
  1026.     cbPtr->VolumeID = VolumeID;
  1027.     cbPtr->DirID = DirID;
  1028.     cbPtr->FileBitmap = FileBitmap;
  1029.     cbPtr->DirBitmap = DirBitmap;
  1030.     cbPtr->ReqCount = ReqCount;
  1031.     cbPtr->StartIndex = StartIndex;
  1032.     cbPtr->MaxReplySize = MaxReplySize;
  1033.     
  1034.     fCBptr = &(cbPtr->marker);
  1035.     this->pathPush( PathType, Pathname );
  1036.  
  1037.     return this->MakeAFPCall();
  1038. }
  1039.  
  1040.  
  1041. OSErr TAFPSession::CreateDir( short VolumeID,
  1042.                               long DirID,
  1043.                               Byte PathType,
  1044.                               char * Pathname )
  1045. {
  1046.     struct commandBuffer {
  1047.         Byte command;
  1048.         Byte filler;
  1049.         short VolumeID;
  1050.         long DirID;
  1051.         char marker;
  1052.     } *cbPtr;
  1053.     
  1054.     this->Debug(0, "CreateDir");
  1055.  
  1056.     fCBSize = sizeof( commandBuffer );
  1057.     fRBSize = kMaxBufSize;
  1058.     cbPtr = (commandBuffer *)fCBStart;
  1059.     
  1060.     cbPtr->command = afpDirCreate;
  1061.     cbPtr->filler = '\0';
  1062.     cbPtr->VolumeID = VolumeID;
  1063.     cbPtr->DirID = DirID;
  1064.     
  1065.     fCBptr = &(cbPtr->marker);
  1066.     this->pathPush( PathType, Pathname );
  1067.     
  1068.     this->MakeAFPCall();
  1069.     
  1070.     fDirID = *(long *)fRBStart;
  1071.     
  1072.     return fErrResult;
  1073. }
  1074.  
  1075.  
  1076.  
  1077.  
  1078. /* File Calls ----------------------------------------------------------- */
  1079.  
  1080. OSErr TAFPSession::SetFileParms( short VolumeID,
  1081.                                 long DirID,
  1082.                                 short Bitmap,
  1083.                                 Byte PathType,
  1084.                                 char * Pathname,
  1085.                                 FileDirBlock& theBlock )
  1086. {
  1087.     struct commandBuffer {
  1088.         Byte command;
  1089.         Byte filler;
  1090.         short VolumeID;
  1091.         long DirID;
  1092.         short Bitmap;
  1093.         char marker;
  1094.     } *cbPtr;
  1095.     
  1096.     this->Debug(0, "SetFileParms");
  1097.     
  1098.     fCBSize = sizeof( commandBuffer );
  1099.     fRBSize = kMaxBufSize;
  1100.     cbPtr = (commandBuffer *)fCBStart;
  1101.     
  1102.     cbPtr->command = afpSetFileParms;
  1103.     cbPtr->filler = '\0';
  1104.     cbPtr->VolumeID = VolumeID;
  1105.     cbPtr->DirID = DirID;
  1106.     cbPtr->Bitmap = Bitmap;
  1107.  
  1108.     fCBptr = &(cbPtr->marker);
  1109.     this->pathPush( PathType, Pathname );
  1110.     this->alignPush();
  1111.     theBlock.FileDirFlag = 0;
  1112.     this->fileDirPush( Bitmap, theBlock );
  1113.  
  1114.     return this->MakeAFPCall();
  1115. }
  1116.  
  1117. OSErr TAFPSession::CreateFile( short VolumeID,
  1118.                               long DirID, 
  1119.                               Byte CreateFlag,
  1120.                               Byte PathType,
  1121.                               char * Pathname )
  1122. { 
  1123.     struct commandBuffer {
  1124.         Byte command;
  1125.         Byte CreateFlag;
  1126.         short VolumeID;
  1127.         long DirID;
  1128.         char marker;
  1129.     } *cbPtr;
  1130.  
  1131.     this->Debug(0, "CreateFile");
  1132.     
  1133.     fCBSize = sizeof( commandBuffer );
  1134.     fRBSize = kMaxBufSize;
  1135.     cbPtr = (commandBuffer *)fCBStart;
  1136.     
  1137.     cbPtr->command = afpFileCreate;
  1138.     cbPtr->CreateFlag = CreateFlag;
  1139.     cbPtr->VolumeID = VolumeID;
  1140.     cbPtr->DirID = DirID;
  1141.  
  1142.     fCBptr = &(cbPtr->marker);
  1143.     
  1144.     this->pathPush( PathType, Pathname );
  1145.  
  1146.      return this->MakeAFPCall();
  1147. }
  1148.  
  1149. OSErr TAFPSession::CopyFile( short SVolumeID,
  1150.                             long SDirID,
  1151.                             Byte SPathType,
  1152.                             char * SPathname,
  1153.                             short DVolumeID,
  1154.                             long DDirID,
  1155.                             Byte DPathType,
  1156.                             char * DPathname,
  1157.                             Byte NewType,
  1158.                             char * NewName )
  1159. {
  1160.     struct commandBuffer {
  1161.         Byte command;
  1162.         Byte filler;
  1163.         short SrcVolumeID;
  1164.         long SrcDirID;
  1165.         short DestVolumeID;
  1166.         long DestDirID;
  1167.         char marker;
  1168.     } *cbPtr;
  1169.     
  1170.     this->Debug(0, "CopyFile");
  1171.     
  1172.     fCBSize = sizeof( commandBuffer );
  1173.     fRBSize = kMaxBufSize;
  1174.     cbPtr = (commandBuffer *)fCBStart;
  1175.     
  1176.     cbPtr->command = afpCopyFile;
  1177.     cbPtr->filler = '\0';
  1178.     cbPtr->SrcVolumeID = SVolumeID;
  1179.     cbPtr->SrcDirID = SDirID;
  1180.     cbPtr->DestVolumeID = DVolumeID;
  1181.     cbPtr->DestDirID = DDirID;
  1182.     
  1183.     fCBptr = &(cbPtr->marker);
  1184.     
  1185.     this->pathPush( SPathType, SPathname );
  1186.     this->pathPush( DPathType, DPathname );
  1187.     this->pathPush( NewType, NewName );
  1188.  
  1189.      return this->MakeAFPCall();
  1190. }
  1191.  
  1192. OSErr TAFPSession::CreateID( short VolumeID,
  1193.                             long DirID,
  1194.                             Byte PathType,
  1195.                             char * Pathname )
  1196. {
  1197.     struct commandBuffer {
  1198.         Byte command;
  1199.         Byte filler;
  1200.         short VolumeID;
  1201.         long DirID;
  1202.         char marker;
  1203.     } *cbPtr;
  1204.     
  1205.     this->Debug(0, "CreateID");
  1206.     
  1207.     fCBSize = sizeof( commandBuffer );
  1208.     fRBSize = kMaxBufSize;
  1209.     cbPtr = (commandBuffer *)fCBStart;
  1210.     
  1211.     cbPtr->command = afpCreateID;
  1212.     cbPtr->filler = '\0';
  1213.     cbPtr->VolumeID = VolumeID;
  1214.     cbPtr->DirID = DirID;
  1215.  
  1216.     fCBptr = &(cbPtr->marker);
  1217.     this->pathPush( PathType, Pathname );
  1218.  
  1219.     this->MakeAFPCall();
  1220.     
  1221.     if (!fErrResult)
  1222.     {
  1223.         fFileID = *(long *)fRBStart;
  1224.     }
  1225.         
  1226.     return fErrResult;
  1227. }
  1228.  
  1229. OSErr TAFPSession::DeleteID( short VolumeID,
  1230.                             long FileID )
  1231. {
  1232.     struct commandBuffer {
  1233.         Byte command;
  1234.         Byte filler;
  1235.         short VolumeID;
  1236.         long FileID;
  1237.     } *cbPtr;
  1238.  
  1239.     this->Debug(0, "DeleteID");
  1240.     
  1241.     fCBSize = sizeof( commandBuffer );
  1242.     fRBSize = kMaxBufSize;
  1243.     cbPtr = (commandBuffer *)fCBStart;
  1244.     
  1245.     cbPtr->command = afpDeleteID;
  1246.     cbPtr->filler = '\0';
  1247.     cbPtr->VolumeID = VolumeID;
  1248.     cbPtr->FileID = FileID;
  1249.         
  1250.     return this->MakeAFPCall();
  1251. }
  1252.  
  1253. OSErr TAFPSession::ResolveID( short VolumeID,
  1254.                                 long FileID,
  1255.                              short Bitmap )
  1256. {
  1257.     struct commandBuffer {
  1258.         Byte command;
  1259.         Byte filler;
  1260.         short VolumeID;
  1261.         long FileID;
  1262.         short Bitmap;
  1263.     } *cbPtr;
  1264.     
  1265.     this->Debug(0, "ResolveID");
  1266.     
  1267.     fCBSize = sizeof( commandBuffer );
  1268.     fRBSize = kMaxBufSize;
  1269.     cbPtr = (commandBuffer *)fCBStart;
  1270.     
  1271.     cbPtr->command = afpResolveID;
  1272.     cbPtr->filler = '\0';
  1273.     cbPtr->VolumeID = VolumeID;
  1274.     cbPtr->FileID = FileID;
  1275.     cbPtr->Bitmap = Bitmap;
  1276.     
  1277.     return this->MakeAFPCall();
  1278. }
  1279.  
  1280.  
  1281. OSErr TAFPSession::ExchangeFiles( short VolumeID,
  1282.                                     long SrcDirID,
  1283.                                     long DestDirID,
  1284.                                     Byte SrcPathType,
  1285.                                  char * SrcPathname,
  1286.                                     Byte DestPathType,
  1287.                                  char * DestPathname )
  1288. {
  1289.     struct commandBuffer {
  1290.         Byte command;
  1291.         Byte filler;
  1292.         short VolumeID;
  1293.         long SrcDirID;
  1294.         long DestDirID;
  1295.         char marker;
  1296.     } *cbPtr;
  1297.     
  1298.     this->Debug(0, "ExchangeFiles");
  1299.     
  1300.     fCBSize = sizeof( commandBuffer );
  1301.     fRBSize = kMaxBufSize;
  1302.     cbPtr = (commandBuffer *)fCBStart;
  1303.     
  1304.     cbPtr->command = afpExchangeFiles;
  1305.     cbPtr->filler = '\0';
  1306.     cbPtr->VolumeID = VolumeID;
  1307.     cbPtr->SrcDirID = SrcDirID;
  1308.     cbPtr->DestDirID = DestDirID;
  1309.  
  1310.     fCBptr = &(cbPtr->marker);
  1311.     this->pathPush( SrcPathType, SrcPathname );
  1312.     this->pathPush( DestPathType, DestPathname );
  1313.  
  1314.     return this->MakeAFPCall();
  1315. }
  1316.  
  1317.  
  1318.  
  1319.  
  1320. /* Directory-File Calls ----------------------------------------------------------- */
  1321.  
  1322. OSErr TAFPSession::CatSearch( short VolumeID,
  1323.                              long ReqMatches,
  1324.                              CatPositionRec * CatPosition,
  1325.                              short FileRsItBitmap,
  1326.                              short DirRsltBitmap,
  1327.                              short FPFlag,
  1328.                              short ReqBitmap,
  1329.                              FileDirBlock& Spec1,
  1330.                              FileDirBlock& Spec2,
  1331.                              char * longName )
  1332. {
  1333.     struct commandBuffer {
  1334.         Byte command;
  1335.         Byte filler;
  1336.         short VolumeID;
  1337.         long ReqMatches;
  1338.         long filler2;
  1339.         CatPositionRec CatPosition;
  1340.         short FileRsItBitmap;
  1341.         short DirRsltBitmap;
  1342.         short FPFlag;
  1343.         short ReqBitmap;
  1344.         char marker;
  1345.     } *cbPtr;
  1346.     CatPositionRec * CatPtr;
  1347.     int i;
  1348.  
  1349.     this->Debug(0, "CatSearch");
  1350.     
  1351.     fCBSize = sizeof( commandBuffer );
  1352.     fRBSize = kMaxBufSize;
  1353.     cbPtr = (commandBuffer *)fCBStart;
  1354.     
  1355.     cbPtr->command = afpCatSearch;
  1356.     cbPtr->filler = '\0';
  1357.     cbPtr->VolumeID = VolumeID;
  1358.     cbPtr->ReqMatches = ReqMatches;
  1359.     cbPtr->filler2 = 0;
  1360.     cbPtr->CatPosition.initialize = CatPosition->initialize;
  1361.     for (i = 0; i < 6; i++)
  1362.     {
  1363.         cbPtr->CatPosition.priv[i] = CatPosition->priv[i];
  1364.     }
  1365.     cbPtr->FileRsItBitmap = FileRsItBitmap;
  1366.     cbPtr->DirRsltBitmap = DirRsltBitmap;
  1367.     cbPtr->FPFlag = FPFlag;
  1368.     cbPtr->ReqBitmap = ReqBitmap;
  1369.     fCBptr = &(cbPtr->marker);
  1370.     this->specPush( ReqBitmap, Spec1, longName );
  1371.     this->specPush( ReqBitmap, Spec2, "" );
  1372.         
  1373.     this->MakeAFPCall();
  1374.     fActCount = *(long *)(fRBptr + 20);
  1375.     CatPtr = (CatPositionRec *)fRBptr;
  1376.     CatPosition->initialize = CatPtr->initialize;
  1377.     for (i = 0; i < 6; i++)
  1378.     {
  1379.         CatPosition->priv[i] = CatPtr->priv[i];
  1380.     }
  1381.     return fErrResult;
  1382. }
  1383.  
  1384.  
  1385. OSErr TAFPSession::GetFileDirParms( short VolumeID,
  1386.                                    long DirID,
  1387.                                    short FileBitmap,
  1388.                                    short DirBitmap,
  1389.                                    Byte PathType,
  1390.                                    char * Pathname )
  1391. {
  1392.     struct commandBuffer {
  1393.         Byte command;
  1394.         Byte filler;
  1395.         short VolumeID;
  1396.         long DirID;
  1397.         short FileBitmap;
  1398.         short DirBitmap;
  1399.         char marker;
  1400.     } *cbPtr;
  1401.     
  1402.     this->Debug(0, "GetFileDirParms");
  1403.     
  1404.     fCBSize = sizeof( commandBuffer );
  1405.     fRBSize = kMaxBufSize;
  1406.     cbPtr = (commandBuffer *)fCBStart;
  1407.     
  1408.     cbPtr->command = afpGetFlDrParms;
  1409.     cbPtr->filler = '\0';
  1410.     cbPtr->VolumeID = VolumeID;
  1411.     cbPtr->DirID = DirID;
  1412.     cbPtr->FileBitmap = FileBitmap;
  1413.     cbPtr->DirBitmap = DirBitmap;
  1414.  
  1415.     fCBptr = &(cbPtr->marker);
  1416.     this->pathPush( PathType, Pathname );
  1417.  
  1418.     return this->MakeAFPCall();
  1419. }
  1420.  
  1421. OSErr TAFPSession::SetFileDirParms( short VolumeID,
  1422.                                    long DirID,
  1423.                                    short Bitmap,
  1424.                                    Byte PathType,
  1425.                                    char * Pathname,
  1426.                                    FileDirBlock& theBlock )
  1427. {
  1428.     struct commandBuffer {
  1429.         Byte command;
  1430.         Byte filler;
  1431.         short VolumeID;
  1432.         long DirID;
  1433.         short Bitmap;
  1434.         char marker;
  1435.     } *cbPtr;
  1436.     
  1437.     this->Debug(0, "SetFileDirParms");
  1438.     
  1439.     fCBSize = sizeof( commandBuffer );
  1440.     fRBSize = kMaxBufSize;
  1441.     cbPtr = (commandBuffer *)fCBStart;
  1442.     
  1443.     cbPtr->command = afpSetFlDrParms;
  1444.     cbPtr->filler = '\0';
  1445.     cbPtr->VolumeID = VolumeID;
  1446.     cbPtr->DirID = DirID;
  1447.     cbPtr->Bitmap = Bitmap;
  1448.  
  1449.     fCBptr = &(cbPtr->marker);
  1450.     this->pathPush( PathType, Pathname );
  1451.     this->alignPush();
  1452.     this->fileDirPush( Bitmap, theBlock );
  1453.  
  1454.     return this->MakeAFPCall();
  1455. }
  1456.  
  1457. OSErr TAFPSession::Rename( short VolumeID,
  1458.                           long DirID,
  1459.                           Byte PathType,
  1460.                           char * Pathname,
  1461.                           Byte NewType,
  1462.                           char * NewName )
  1463. {
  1464.     struct commandBuffer {
  1465.         Byte command;
  1466.         Byte filler;
  1467.         short VolumeID;
  1468.         long DirID;
  1469.         char marker;
  1470.     } *cbPtr;
  1471.     
  1472.     this->Debug(0, "Rename");
  1473.     
  1474.     fCBSize = sizeof( commandBuffer );
  1475.     fRBSize = kMaxBufSize;
  1476.     cbPtr = (commandBuffer *)fCBStart;
  1477.     
  1478.     cbPtr->command = afpRename;
  1479.     cbPtr->filler = '\0';
  1480.     cbPtr->VolumeID = VolumeID;
  1481.     cbPtr->DirID = DirID;
  1482.  
  1483.     fCBptr = &(cbPtr->marker);
  1484.     this->pathPush( PathType, Pathname );
  1485.     this->pathPush( NewType, NewName );
  1486.  
  1487.     return this->MakeAFPCall();
  1488. }
  1489.  
  1490. OSErr TAFPSession::Delete( short VolumeID,
  1491.                           long DirID,
  1492.                           Byte PathType,
  1493.                           char * Pathname )
  1494. {
  1495.     struct commandBuffer {
  1496.         Byte command;
  1497.         Byte filler;
  1498.         short VolumeID;
  1499.         long DirID;
  1500.         char marker;
  1501.     } *cbPtr;
  1502.     
  1503.     this->Debug(0, "Delete");
  1504.     
  1505.     fCBSize = sizeof( commandBuffer );
  1506.     fRBSize = kMaxBufSize;
  1507.     cbPtr = (commandBuffer *)fCBStart;
  1508.     
  1509.     cbPtr->command = afpDelete;
  1510.     cbPtr->filler = '\0';
  1511.     cbPtr->VolumeID = VolumeID;
  1512.     cbPtr->DirID = DirID;
  1513.  
  1514.     fCBptr = &(cbPtr->marker);
  1515.     this->pathPush( PathType, Pathname );
  1516.     
  1517.     return this->MakeAFPCall();
  1518. }
  1519.  
  1520. OSErr TAFPSession::MoveAndRename( short VolumeID,
  1521.                                  long SrcDirID,
  1522.                                  long DestDirID,
  1523.                                  Byte SrcPathType,
  1524.                                  char * SrcPathname,
  1525.                                  Byte DestPathType,
  1526.                                  char * DestPathname,
  1527.                                  Byte NewType,
  1528.                                  char * NewName )
  1529. {
  1530.     struct commandBuffer {
  1531.         Byte command;
  1532.         Byte filler;
  1533.         short VolumeID;
  1534.         long SrcDirID;
  1535.         long DestDirID;
  1536.         char marker;
  1537.     } *cbPtr;
  1538.     
  1539.     this->Debug(0, "MoveAndRename");
  1540.     
  1541.     fCBSize = sizeof( commandBuffer );
  1542.     fRBSize = kMaxBufSize;
  1543.     cbPtr = (commandBuffer *)fCBStart;
  1544.     
  1545.     cbPtr->command = afpMove;
  1546.     cbPtr->filler = '\0';
  1547.     cbPtr->VolumeID = VolumeID;
  1548.     cbPtr->SrcDirID = SrcDirID;
  1549.     cbPtr->DestDirID = DestDirID;
  1550.  
  1551.     fCBptr = &(cbPtr->marker);
  1552.     this->pathPush( SrcPathType, SrcPathname );
  1553.     this->pathPush( DestPathType, DestPathname );
  1554.     this->pathPush( NewType, NewName );
  1555.     
  1556.     return this->MakeAFPCall();
  1557. }
  1558.  
  1559.  
  1560.  
  1561. /* Fork Calls ----------------------------------------------------------- */
  1562.  
  1563. OSErr TAFPSession::GetForkParms( short OForkRefNum, short Bitmap )
  1564. {
  1565.     struct commandBuffer {
  1566.         Byte command;
  1567.         Byte filler;
  1568.         short OForkRefNum;
  1569.         short Bitmap;
  1570.     } *cbPtr;
  1571.     
  1572.     this->Debug(0, "GetForkParms");
  1573.     
  1574.     fCBSize = sizeof( commandBuffer );
  1575.     fRBSize = kMaxBufSize;
  1576.     cbPtr = (commandBuffer *)fCBStart;
  1577.     
  1578.     cbPtr->command = afpGetForkParms;
  1579.     cbPtr->filler = '\0';
  1580.     cbPtr->OForkRefNum = OForkRefNum;
  1581.     cbPtr->Bitmap = Bitmap;
  1582.  
  1583.     return this->MakeAFPCall();
  1584. }
  1585.  
  1586. OSErr TAFPSession::SetForkParms( short OForkRefNum,
  1587.                                 short Bitmap,
  1588.                                 long ForkLength )
  1589. {
  1590.     struct commandBuffer {
  1591.         Byte command;
  1592.         Byte filler;
  1593.         short OForkRefNum;
  1594.         short Bitmap;
  1595.         long ForkLength;
  1596.     } *cbPtr;
  1597.         
  1598.     this->Debug(0, "SetForkParms");
  1599.     
  1600.     fCBSize = sizeof( commandBuffer );
  1601.     fRBSize = kMaxBufSize;
  1602.     cbPtr = (commandBuffer *)fCBStart;
  1603.     
  1604.     cbPtr->command = afpSetForkParms;
  1605.     cbPtr->filler = '\0';
  1606.     cbPtr->OForkRefNum = OForkRefNum;
  1607.     cbPtr->Bitmap = Bitmap;
  1608.     cbPtr->ForkLength = ForkLength;
  1609.  
  1610.     return this->MakeAFPCall();
  1611. }
  1612.  
  1613. OSErr TAFPSession::OpenFork(    Byte RsrcDataFlag,
  1614.                             short VolumeID,
  1615.                             long DirID,
  1616.                             short Bitmap,
  1617.                             short AccessMode,
  1618.                             Byte PathType,
  1619.                             char * Pathname )
  1620. {
  1621.     struct commandBuffer {
  1622.         Byte command;
  1623.         Byte RsrcDataFlag;
  1624.         short VolumeID;
  1625.         long DirID;
  1626.         short Bitmap;
  1627.         short AccessMode;
  1628.         char marker;
  1629.     } *cbPtr;
  1630.     
  1631.     struct replyBuffer {
  1632.         short Bitmap;
  1633.         short OForkRefNum;
  1634.     } *rbPtr;
  1635.         
  1636.     this->Debug(0, "OpenFork");
  1637.     
  1638.     fCBSize = sizeof( commandBuffer );
  1639.     fRBSize = kMaxBufSize;
  1640.     cbPtr = (commandBuffer *)fCBStart;
  1641.     
  1642.     cbPtr->command = afpOpenFork;
  1643.     cbPtr->RsrcDataFlag = RsrcDataFlag;
  1644.     cbPtr->VolumeID = VolumeID;
  1645.     cbPtr->DirID = DirID;
  1646.     cbPtr->Bitmap = Bitmap;
  1647.     cbPtr->AccessMode = AccessMode;
  1648.  
  1649.     fCBptr = &(cbPtr->marker);
  1650.     this->pathPush( PathType, Pathname );
  1651.  
  1652.     this->MakeAFPCall();
  1653.  
  1654.     rbPtr = (replyBuffer *)fRBStart;
  1655.     fOForkRefNum = rbPtr->OForkRefNum;
  1656.     
  1657.     return fErrResult;
  1658. }
  1659.  
  1660. OSErr TAFPSession::Read( short OForkRefNum,
  1661.                         long Offset,
  1662.                         long ReqCount,
  1663.                         Byte NewlineMask,
  1664.                         Byte NewlineChar,
  1665.                         char * buffer )
  1666. {
  1667.     struct commandBuffer {
  1668.         Byte command;
  1669.         Byte filler;
  1670.         short OForkRefNum;
  1671.         long Offset;
  1672.         long ReqCount;
  1673.         Byte NewlineMask;
  1674.         Byte NewlineChar;
  1675.     } *cbPtr;
  1676.         
  1677.     this->Debug(0, "Read");
  1678.     
  1679.     fCBSize = sizeof( commandBuffer );
  1680.     fRBSize = 0;
  1681.     cbPtr = (commandBuffer *)fCBStart;
  1682.     
  1683.     cbPtr->command = afpRead;
  1684.     cbPtr->filler = '\0';
  1685.     cbPtr->OForkRefNum = OForkRefNum;
  1686.     cbPtr->Offset = Offset;
  1687.     cbPtr->ReqCount = ReqCount;
  1688.     cbPtr->NewlineMask = NewlineMask;
  1689.     cbPtr->NewlineChar = NewlineChar;
  1690.  
  1691.     this->DoCommand( fCBStart, fCBSize, buffer, 0 );
  1692.     
  1693.     fActCount = cbPtr->ReqCount;
  1694.     fOffset = cbPtr->Offset;
  1695.     
  1696.     return fErrResult;
  1697. }
  1698.  
  1699. OSErr TAFPSession::Write( short OForkRefNum,
  1700.                          long Offset,
  1701.                          long ReqCount,
  1702.                          Byte StartEndFlag,
  1703.                          char * buffer )
  1704. {
  1705.     struct commandBuffer {
  1706.         Byte command;
  1707.         Byte StartEndFlag;
  1708.         short OForkRefNum;
  1709.         long Offset;
  1710.         long ReqCount;
  1711.     } *cbPtr;
  1712.         
  1713.     this->Debug(0, "Write");
  1714.     
  1715.     fCBSize = sizeof( commandBuffer );
  1716.     fRBSize = 4;
  1717.     cbPtr = (commandBuffer *)fCBStart;
  1718.     
  1719.     cbPtr->command = afpWrite;
  1720.     cbPtr->StartEndFlag = StartEndFlag;
  1721.     cbPtr->OForkRefNum = OForkRefNum;
  1722.     cbPtr->Offset = Offset;
  1723.     cbPtr->ReqCount = ReqCount;
  1724.  
  1725.     DoWrite( fCBStart, fCBSize, fRBStart, fRBSize, buffer, 0 );
  1726.     
  1727.     fActCount = cbPtr->ReqCount;
  1728.     fOffset = *(long *)fRBStart;
  1729.     
  1730.     return fErrResult;
  1731. }
  1732.  
  1733. OSErr TAFPSession::FlushFork( short OForkRefNum )
  1734. {
  1735.     struct commandBuffer {
  1736.         Byte command;
  1737.         Byte filler;
  1738.         short OForkRefNum;
  1739.     } *cbPtr;
  1740.     
  1741.     this->Debug(0, "FlushFork");
  1742.     
  1743.     fCBSize = sizeof( commandBuffer );
  1744.     fRBSize = kMinBufSize;
  1745.     cbPtr = (commandBuffer *)fCBStart;
  1746.  
  1747.     cbPtr->command = afpForkFlush;
  1748.     cbPtr->filler = '\0';
  1749.     cbPtr->OForkRefNum = OForkRefNum;
  1750.  
  1751.     return this->MakeAFPCall();
  1752. }
  1753.  
  1754. OSErr TAFPSession::ByteRangeLock( Byte StartEndFlag,
  1755.                                  short OForkRefNum,
  1756.                                  long Offset,
  1757.                                  long Length )
  1758. {
  1759.     struct commandBuffer {
  1760.         Byte command;
  1761.         Byte Flag;
  1762.         short OForkRefNum;
  1763.         long Offset;
  1764.         long Length;
  1765.     } *cbPtr;
  1766.  
  1767.     this->Debug(0, "ByteRangeLock");
  1768.     
  1769.     fCBSize = sizeof( commandBuffer );
  1770.     fRBSize = 4;
  1771.     cbPtr = (commandBuffer *)fCBStart;
  1772.  
  1773.     cbPtr->command = afpByteRangeLock;
  1774.     cbPtr->Flag = StartEndFlag;
  1775.     cbPtr->OForkRefNum = OForkRefNum;
  1776.     cbPtr->Offset = Offset;
  1777.     cbPtr->Length = Length;
  1778.     
  1779.     return this->MakeAFPCall();
  1780. }
  1781.  
  1782. OSErr TAFPSession::CloseFork( short OForkRefNum )
  1783. {
  1784.     struct commandBuffer {
  1785.         Byte command;
  1786.         Byte filler;
  1787.         short OForkRefNum;
  1788.     } *cbPtr;
  1789.  
  1790.     this->Debug(0, "CloseFork");
  1791.     
  1792.     fCBSize = sizeof( commandBuffer );
  1793.     fRBSize = kMinBufSize;
  1794.     cbPtr = (commandBuffer *)fCBStart;
  1795.  
  1796.     cbPtr->command = afpForkClose;
  1797.     cbPtr->filler = '\0';
  1798.     cbPtr->OForkRefNum = OForkRefNum;
  1799.     
  1800.     return this->MakeAFPCall();
  1801. }
  1802.  
  1803.  
  1804.  
  1805. /* Desktop Calls ----------------------------------------------------------- */
  1806.  
  1807. OSErr TAFPSession::OpenDT( short VolumeID )
  1808. {
  1809.     struct commandBuffer {
  1810.         Byte command;
  1811.         Byte filler;
  1812.         short VolumeID;
  1813.     } *cbPtr;
  1814.  
  1815.     this->Debug(0, "CloseFork");
  1816.     
  1817.     fCBSize = sizeof( commandBuffer );
  1818.     fRBSize = kMinBufSize;
  1819.     cbPtr = (commandBuffer *)fCBStart;
  1820.  
  1821.     cbPtr->command = afpDTOpen;
  1822.     cbPtr->filler = '\0';
  1823.     cbPtr->VolumeID = VolumeID;
  1824.     
  1825.     this->MakeAFPCall();
  1826.     
  1827.     fDTRefNum = *(short *)fRBStart;
  1828.     
  1829.     return fErrResult;
  1830. }
  1831.  
  1832. OSErr TAFPSession::CloseDT( short DTRefNum )
  1833. {
  1834.     struct commandBuffer {
  1835.         Byte command;
  1836.         Byte filler;
  1837.         short DTRefNum;
  1838.     } *cbPtr;
  1839.  
  1840.     this->Debug(0, "CloseDT");
  1841.     
  1842.     fCBSize = sizeof( commandBuffer );
  1843.     fRBSize = kMinBufSize;
  1844.     cbPtr = (commandBuffer *)fCBStart;
  1845.  
  1846.     cbPtr->command = afpDTClose;
  1847.     cbPtr->filler = '\0';
  1848.     cbPtr->DTRefNum = DTRefNum;
  1849.     
  1850.     return this->MakeAFPCall();
  1851. }
  1852.  
  1853. OSErr TAFPSession::AddIcon(  short DTRefNum,
  1854.                             ResType FileCreator,
  1855.                             ResType FileType,
  1856.                             Byte IconType,
  1857.                             ResType IconTag,
  1858.                             short BitmapSize,
  1859.                             Ptr IBitmapPtr )
  1860. {
  1861.     struct commandBuffer {
  1862.         Byte command;
  1863.         Byte filler;
  1864.         short DTRefNum;
  1865.         long FileCreator;
  1866.         long FileType;
  1867.         Byte IconType;
  1868.         Byte filler2;
  1869.         long IconTag;
  1870.         short BitmapSize;
  1871.     } *cbPtr;
  1872.  
  1873.     this->Debug(0, "AddIcon");
  1874.     
  1875.     fCBSize = sizeof( commandBuffer );
  1876.     fRBSize = kMinBufSize;
  1877.     cbPtr = (commandBuffer *)fCBStart;
  1878.  
  1879.     cbPtr->command = afpAddIcon;
  1880.     cbPtr->filler = '\0';
  1881.     cbPtr->DTRefNum = DTRefNum;
  1882.     cbPtr->FileCreator = FileCreator;
  1883.     cbPtr->FileType = FileType;
  1884.     cbPtr->IconType = IconType;
  1885.     cbPtr->filler2 = '\0';
  1886.     cbPtr->IconTag = IconTag;
  1887.     cbPtr->BitmapSize = BitmapSize;
  1888.     
  1889.     return DoWrite( fCBStart, fCBSize, fRBStart, fRBSize, IBitmapPtr, BitmapSize );
  1890. }
  1891.  
  1892. OSErr TAFPSession::GetIcon(    short DTRefNum,
  1893.                             ResType FileCreator,
  1894.                             ResType FileType,
  1895.                             Byte IconType,
  1896.                             short Length )
  1897. {
  1898.     struct commandBuffer {
  1899.         Byte command;
  1900.         Byte filler;
  1901.         short DTRefNum;
  1902.         long FileCreator;
  1903.         long FileType;
  1904.         Byte IconType;
  1905.         Byte filler2;
  1906.         short Length;
  1907.     } *cbPtr;
  1908.  
  1909.     this->Debug(0, "GetIcon");
  1910.     
  1911.     fCBSize = sizeof( commandBuffer );
  1912.     fRBSize = kMaxBufSize;
  1913.     cbPtr = (commandBuffer *)fCBStart;
  1914.  
  1915.     cbPtr->command = afpGetIcon;
  1916.     cbPtr->filler = '\0';
  1917.     cbPtr->DTRefNum = DTRefNum;
  1918.     cbPtr->FileCreator = FileCreator;
  1919.     cbPtr->FileType = FileType;
  1920.     cbPtr->IconType = IconType;
  1921.     cbPtr->filler2 = '\0';
  1922.     cbPtr->Length = Length;
  1923.  
  1924.     return this->MakeAFPCall();
  1925. }
  1926.  
  1927. OSErr TAFPSession::GetIconInfo( short DTRefNum,
  1928.                                 ResType FileCreator,
  1929.                                 short IconIndex )
  1930. {
  1931.     struct commandBuffer {
  1932.         Byte command;
  1933.         Byte filler;
  1934.         short DTRefNum;
  1935.         long FileCreator;
  1936.         short IconIndex;
  1937.     } *cbPtr;
  1938.  
  1939.     this->Debug(0, "GetIconInfo");
  1940.     
  1941.     fCBSize = sizeof( commandBuffer );
  1942.     fRBSize = 12;
  1943.     cbPtr = (commandBuffer *)fCBStart;
  1944.  
  1945.     cbPtr->command = afpGtIcnInfo;
  1946.     cbPtr->filler = '\0';
  1947.     cbPtr->DTRefNum = DTRefNum;
  1948.     cbPtr->FileCreator = FileCreator;
  1949.     cbPtr->IconIndex = IconIndex;
  1950.  
  1951.     return this->MakeAFPCall();
  1952. }
  1953.  
  1954. OSErr TAFPSession::AddAPPL(  short DTRefNum,
  1955.                             long DirID,
  1956.                             ResType FileCreator,
  1957.                             ResType APPLTag,
  1958.                             short PathType,
  1959.                             char * Pathname )
  1960. {
  1961.     struct commandBuffer {
  1962.         Byte command;
  1963.         Byte filler;
  1964.         short DTRefNum;
  1965.         long DirID;
  1966.         long FileCreator;
  1967.         long APPLTag;
  1968.         char marker;
  1969.     } *cbPtr;
  1970.  
  1971.     this->Debug(0, "AddAPPL");
  1972.     
  1973.     fCBSize = sizeof( commandBuffer );
  1974.     fRBSize = kMinBufSize;
  1975.     cbPtr = (commandBuffer *)fCBStart;
  1976.  
  1977.     cbPtr->command = afpAddAPPL;
  1978.     cbPtr->filler = '\0';
  1979.     cbPtr->DTRefNum = DTRefNum;
  1980.     cbPtr->DirID = DirID;
  1981.     cbPtr->FileCreator = FileCreator;
  1982.     cbPtr->APPLTag = APPLTag;
  1983.     
  1984.     fCBptr = &(cbPtr->marker);
  1985.     this->pathPush( PathType, Pathname );
  1986.  
  1987.     return this->MakeAFPCall();
  1988. }
  1989.  
  1990. OSErr TAFPSession::RemoveAPPL( short DTRefNum,
  1991.                               long DirID,
  1992.                               ResType FileCreator,
  1993.                               short PathType,
  1994.                               char * Pathname )
  1995. {
  1996.     struct commandBuffer {
  1997.         Byte command;
  1998.         Byte filler;
  1999.         short DTRefNum;
  2000.         long DirID;
  2001.         long FileCreator;
  2002.         char marker;
  2003.     } *cbPtr;
  2004.  
  2005.     this->Debug(0, "RemoveAPPL");
  2006.     
  2007.     fCBSize = sizeof( commandBuffer );
  2008.     fRBSize = kMinBufSize;
  2009.     cbPtr = (commandBuffer *)fCBStart;
  2010.  
  2011.     cbPtr->command = afpRmvAPPL;
  2012.     cbPtr->filler = '\0';
  2013.     cbPtr->DTRefNum = DTRefNum;
  2014.     cbPtr->DirID = DirID;
  2015.     cbPtr->FileCreator = FileCreator;
  2016.     
  2017.     fCBptr = &(cbPtr->marker);
  2018.     this->pathPush( PathType, Pathname );
  2019.  
  2020.     return this->MakeAFPCall();
  2021. }
  2022.  
  2023. OSErr TAFPSession::GetAPPL( short DTRefNum,
  2024.                            ResType FileCreator,
  2025.                            short APPLIndex,
  2026.                            short Bitmap )
  2027. {
  2028.     struct commandBuffer {
  2029.         Byte command;
  2030.         Byte filler;
  2031.         short DTRefNum;
  2032.         long FileCreator;
  2033.         short APPLIndex;
  2034.         short Bitmap;
  2035.     } *cbPtr;
  2036.  
  2037.     this->Debug(0, "GetAPPL");
  2038.     
  2039.     fCBSize = sizeof( commandBuffer );
  2040.     fRBSize = kMaxBufSize;
  2041.     cbPtr = (commandBuffer *)fCBStart;
  2042.  
  2043.     cbPtr->command = afpGetAPPL;
  2044.     cbPtr->filler = '\0';
  2045.     cbPtr->DTRefNum = DTRefNum;
  2046.     cbPtr->FileCreator = FileCreator;
  2047.     cbPtr->APPLIndex = APPLIndex;
  2048.     cbPtr->Bitmap = Bitmap;
  2049.     
  2050.     return this->MakeAFPCall();
  2051. }
  2052.  
  2053. OSErr TAFPSession::AddComment( short DTRefNum,
  2054.                               long DirID,
  2055.                               Byte PathType,
  2056.                                  char * Pathname,
  2057.                                  char * Comment )
  2058. {
  2059.     struct commandBuffer {
  2060.         Byte command;
  2061.         Byte filler;
  2062.         short DTRefNum;
  2063.         long DirID;
  2064.         char marker;
  2065.     } *cbPtr;
  2066.  
  2067.     this->Debug(0, "AddComment");
  2068.     
  2069.     fCBSize = sizeof( commandBuffer );
  2070.     fRBSize = kMaxBufSize;
  2071.     cbPtr = (commandBuffer *)fCBStart;
  2072.  
  2073.     cbPtr->command = afpAddCmt;
  2074.     cbPtr->filler = '\0';
  2075.     cbPtr->DTRefNum = DTRefNum;
  2076.     cbPtr->DirID = DirID;
  2077.     
  2078.     fCBptr = &(cbPtr->marker);
  2079.     this->pathPush( PathType, Pathname );
  2080.     this->alignPush();
  2081.     this->stringPush( Comment );
  2082.  
  2083.     return this->MakeAFPCall();
  2084. }
  2085.  
  2086. OSErr TAFPSession::RemoveComment( short DTRefNum,
  2087.                                  long DirID,
  2088.                                  Byte PathType,
  2089.                                  char * Pathname )
  2090. {
  2091.     struct commandBuffer {
  2092.         Byte command;
  2093.         Byte filler;
  2094.         short DTRefNum;
  2095.         long DirID;
  2096.         char marker;
  2097.     } *cbPtr;
  2098.  
  2099.     this->Debug(0, "RemoveComment");
  2100.     
  2101.     fCBSize = sizeof( commandBuffer );
  2102.     fRBSize = kMaxBufSize;
  2103.     cbPtr = (commandBuffer *)fCBStart;
  2104.  
  2105.     cbPtr->command = afpRmvCmt;
  2106.     cbPtr->filler = '\0';
  2107.     cbPtr->DTRefNum = DTRefNum;
  2108.     cbPtr->DirID = DirID;
  2109.     
  2110.     fCBptr = &(cbPtr->marker);
  2111.     this->pathPush( PathType, Pathname );
  2112.  
  2113.     return this->MakeAFPCall();
  2114. }
  2115.  
  2116. OSErr TAFPSession::GetComment( short DTRefNum,
  2117.                               long DirID,
  2118.                               Byte PathType,
  2119.                               char * Pathname )
  2120. {
  2121.     struct commandBuffer {
  2122.         Byte command;
  2123.         Byte filler;
  2124.         short DTRefNum;
  2125.         long DirID;
  2126.         char marker;
  2127.     } *cbPtr;
  2128.  
  2129.     this->Debug(0, "GetComment");
  2130.     
  2131.     fCBSize = sizeof( commandBuffer );
  2132.     fRBSize = kMaxBufSize;
  2133.     cbPtr = (commandBuffer *)fCBStart;
  2134.  
  2135.     cbPtr->command = afpGetCmt;
  2136.     cbPtr->filler = '\0';
  2137.     cbPtr->DTRefNum = DTRefNum;
  2138.     cbPtr->DirID = DirID;
  2139.     
  2140.     fCBptr = &(cbPtr->marker);
  2141.     this->pathPush( PathType, Pathname );
  2142.  
  2143.     return this->MakeAFPCall();
  2144. }
  2145.